home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 July: Mac OS SDK / Dev.CD Jul 99 SDK1.toast / Development Kits / Mac OS / Interfaces&Libraries / Universal / Interfaces / AIncludes / Slots.a < prev    next >
Encoding:
Text File  |  1998-08-17  |  26.3 KB  |  1,014 lines  |  [TEXT/MPS ]
  1. ;
  2. ;    File:        Slots.a
  3. ;
  4. ;    Contains:    Slot Manager Interfaces.
  5. ;
  6. ;    Version:    Technology:    System 7.5
  7. ;                Release:    Universal Interfaces 3.2
  8. ;
  9. ;    Copyright:    © 1986-1993, 1995-1998 by Apple Computer, Inc., all rights reserved
  10. ;
  11. ;    Bugs?:        For bug reports, consult the following page on
  12. ;                the World Wide Web:
  13. ;
  14. ;                    http://developer.apple.com/bugreporter/
  15. ;
  16. ;
  17.     IF &TYPE('__SLOTS__') = 'UNDEFINED' THEN
  18. __SLOTS__ SET 1
  19.  
  20.     IF &TYPE('__MACTYPES__') = 'UNDEFINED' THEN
  21.     include 'MacTypes.a'
  22.     ENDIF
  23.     IF &TYPE('__EVENTS__') = 'UNDEFINED' THEN
  24.     include 'Events.a'
  25.     ENDIF
  26.     IF &TYPE('__FILES__') = 'UNDEFINED' THEN
  27.     include 'Files.a'
  28.     ENDIF
  29.  
  30.  
  31. fDontUse                        EQU        0                    ;old slotmgr put fcardIsChanged here
  32. fCardIsChanged                    EQU        1                    ;card is Changed field in StatusFlags field of sInfoArray
  33. fTempEnabled                    EQU        2                    ;slot is temporarily enabled
  34. fCkForNext                        EQU        0                    ;check for NEXT sRsrc in SRT            (SearchSRT)
  35. fCkReserved                        EQU        1                    ;check reserved field for zero         (ReadPBSize)
  36. fWarmStart                        EQU        2                    ;warm start, else cold start            (PrimaryInit)
  37. fClear                            EQU        3                    ;clear the memory                        (sNewPtr)
  38. fSys                            EQU        4                    ;alloc  on system heap                 (sNewPtr)
  39. fConsecBytes                    EQU        5                    ;calc step value for consecutive bytes (CalcStep)
  40.  
  41. stateNil                        EQU        0                    ;State
  42. stateSDMInit                    EQU        1                    ;:Slot declaration manager Init
  43. statePRAMInit                    EQU        2                    ;:sPRAM record init
  44. statePInit                        EQU        3                    ;:Primary init
  45. stateSInit                        EQU        4                    ;:Secondary init
  46.  
  47.                                                             ; flags for spParamData 
  48. fall                            EQU        0                    ; bit 0: set=search enabled/disabled sRsrc's 
  49. foneslot                        EQU        1                    ;    1: set=search sRsrc's in given slot only 
  50. fnext                            EQU        2                    ;    2: set=search for next sRsrc 
  51.  
  52.                                                             ; Misc masks 
  53. catMask                            EQU        $08                    ; sets spCategory field of spTBMask (bit 3) 
  54. cTypeMask                        EQU        $04                    ; sets spCType    field of spTBMask (bit 2) 
  55. drvrSWMask                        EQU        $02                    ; sets spDrvrSW   field of spTBMask (bit 1) 
  56. drvrHWMask                        EQU        $01                    ; sets spDrvrHW      field of spTBMask (bit 0) 
  57. SlotIntQElement            RECORD 0
  58. sqLink                     ds.l    1                ; offset: $0 (0)        ; ptr to next element
  59. sqType                     ds.w    1                ; offset: $4 (4)        ; queue type ID for validity
  60. sqPrio                     ds.w    1                ; offset: $6 (6)        ; priority
  61. sqAddr                     ds.l    1                ; offset: $8 (8)        ; interrupt service routine
  62. sqParm                     ds.l    1                ; offset: $C (12)        ; optional A1 parameter
  63. sizeof                     EQU *                    ; size:   $10 (16)
  64.                         ENDR
  65. ; typedef struct SlotIntQElement *        SQElemPtr
  66.  
  67. SpBlock                    RECORD 0
  68. spResult                 ds.l    1                ; offset: $0 (0)        ; FUNCTION Result
  69. spsPointer                 ds.l    1                ; offset: $4 (4)        ; structure pointer
  70. spSize                     ds.l    1                ; offset: $8 (8)        ; size of structure
  71. spOffsetData             ds.l    1                ; offset: $C (12)        ; offset/data field used by sOffsetData
  72. spIOFileName             ds.l    1                ; offset: $10 (16)        ; ptr to IOFile name for sDisDrvrName
  73. spsExecPBlk                 ds.l    1                ; offset: $14 (20)        ; pointer to sExec parameter block.
  74. spParamData                 ds.l    1                ; offset: $18 (24)        ; misc parameter data (formerly spStackPtr).
  75. spMisc                     ds.l    1                ; offset: $1C (28)        ; misc field for SDM.
  76. spReserved                 ds.l    1                ; offset: $20 (32)        ; reserved for future expansion
  77. spIOReserved             ds.w    1                ; offset: $24 (36)        ; Reserved field of Slot Resource Table
  78. spRefNum                 ds.w    1                ; offset: $26 (38)        ; RefNum
  79. spCategory                 ds.w    1                ; offset: $28 (40)        ; sType: Category
  80. spCType                     ds.w    1                ; offset: $2A (42)        ; Type
  81. spDrvrSW                 ds.w    1                ; offset: $2C (44)        ; DrvrSW
  82. spDrvrHW                 ds.w    1                ; offset: $2E (46)        ; DrvrHW
  83. spTBMask                 ds.b    1                ; offset: $30 (48)        ; type bit mask bits 0..3 mask words 0..3
  84. spSlot                     ds.b    1                ; offset: $31 (49)        ; slot number
  85. spID                     ds.b    1                ; offset: $32 (50)        ; structure ID
  86. spExtDev                 ds.b    1                ; offset: $33 (51)        ; ID of the external device
  87. spHwDev                     ds.b    1                ; offset: $34 (52)        ; Id of the hardware device.
  88. spByteLanes                 ds.b    1                ; offset: $35 (53)        ; bytelanes from card ROM format block
  89. spFlags                     ds.b    1                ; offset: $36 (54)        ; standard flags
  90. spKey                     ds.b    1                ; offset: $37 (55)        ; Internal use only
  91. sizeof                     EQU *                    ; size:   $38 (56)
  92.                         ENDR
  93. ; typedef struct SpBlock *                SpBlockPtr
  94.  
  95. SInfoRecord                RECORD 0
  96. siDirPtr                 ds.l    1                ; offset: $0 (0)        ; Pointer to directory
  97. siInitStatusA             ds.w    1                ; offset: $4 (4)        ; initialization E
  98. siInitStatusV             ds.w    1                ; offset: $6 (6)        ; status returned by vendor init code
  99. siState                     ds.b    1                ; offset: $8 (8)        ; initialization state
  100. siCPUByteLanes             ds.b    1                ; offset: $9 (9)        ; 0=[d0..d7] 1=[d8..d15]
  101. siTopOfROM                 ds.b    1                ; offset: $A (10)        ; Top of ROM= $FssFFFFx: x is TopOfROM
  102. siStatusFlags             ds.b    1                ; offset: $B (11)        ; bit 0 - card is changed
  103. siTOConst                 ds.w    1                ; offset: $C (12)        ; Time Out C for BusErr
  104. siReserved                 ds.b    2                ; offset: $E (14)        ; reserved
  105. siROMAddr                 ds.l    1                ; offset: $10 (16)        ;  addr of top of ROM 
  106. siSlot                     ds.b    1                ; offset: $14 (20)        ;  slot number 
  107. siPadding                 ds.b    3                ; offset: $15 (21)        ;  reserved 
  108. sizeof                     EQU *                    ; size:   $18 (24)
  109.                         ENDR
  110. ; typedef struct SInfoRecord *            SInfoRecPtr
  111.  
  112. SDMRecord                RECORD 0
  113. sdBEVSave                 ds.l    1                ; offset: $0 (0)        ; Save old BusErr vector
  114. sdBusErrProc             ds.l    1                ; offset: $4 (4)        ; Go here to determine if it is a BusErr
  115. sdErrorEntry             ds.l    1                ; offset: $8 (8)        ; Go here if BusErrProc finds real BusErr
  116. sdReserved                 ds.l    1                ; offset: $C (12)        ; Reserved
  117. sizeof                     EQU *                    ; size:   $10 (16)
  118.                         ENDR
  119. FHeaderRec                RECORD 0
  120. fhDirOffset                 ds.l    1                ; offset: $0 (0)        ; offset to directory
  121. fhLength                 ds.l    1                ; offset: $4 (4)        ; length of ROM
  122. fhCRC                     ds.l    1                ; offset: $8 (8)        ; CRC
  123. fhROMRev                 ds.b    1                ; offset: $C (12)        ; revision of ROM
  124. fhFormat                 ds.b    1                ; offset: $D (13)        ; format - 2
  125. fhTstPat                 ds.l    1                ; offset: $E (14)        ; test pattern
  126. fhReserved                 ds.b    1                ; offset: $12 (18)        ; reserved
  127. fhByteLanes                 ds.b    1                ; offset: $13 (19)        ; ByteLanes
  128. sizeof                     EQU *                    ; size:   $14 (20)
  129.                         ENDR
  130. ; typedef struct FHeaderRec *            FHeaderRecPtr
  131.  
  132. OffsetToDir        EQU            FHeaderRec.fhDirOffset-FHeaderRec.sizeof+1    ; offset to dir ptr    <1.8>
  133.  
  134. ;   
  135. ;       Extended Format header block  -  extended declaration ROM format header for super sRsrc directories.    <H2><SM0>
  136. ;   
  137.  
  138.  
  139.  
  140. XFHeaderRec                RECORD 0
  141. fhXSuperInit             ds.l    1                ; offset: $0 (0)        ; Offset to SuperInit SExecBlock    <fhFormat,offset>
  142. fhXSDirOffset             ds.l    1                ; offset: $4 (4)        ; Offset to SuperDirectory            <$FE,offset>
  143. fhXEOL                     ds.l    1                ; offset: $8 (8)        ; Psuedo end-of-list                <$FF,nil>
  144. fhXSTstPat                 ds.l    1                ; offset: $C (12)        ; TestPattern
  145. fhXDirOffset             ds.l    1                ; offset: $10 (16)        ; Offset to (minimal) directory
  146. fhXLength                 ds.l    1                ; offset: $14 (20)        ; Length of ROM
  147. fhXCRC                     ds.l    1                ; offset: $18 (24)        ; CRC
  148. fhXROMRev                 ds.b    1                ; offset: $1C (28)        ; Revision of ROM
  149. fhXFormat                 ds.b    1                ; offset: $1D (29)        ; Format-2
  150. fhXTstPat                 ds.l    1                ; offset: $1E (30)        ; TestPattern
  151. fhXReserved                 ds.b    1                ; offset: $22 (34)        ; Reserved
  152. fhXByteLanes             ds.b    1                ; offset: $23 (35)        ; ByteLanes
  153. sizeof                     EQU *                    ; size:   $24 (36)
  154.                         ENDR
  155. ; typedef struct XFHeaderRec *            XFHeaderRecPtr
  156.  
  157. XFHdrExtraSize    Equ            XFHeaderRec.sizeof-FHeaderRec.sizeof        ; (extended - standard) delta
  158. XOffsetToDir    Equ            XFHeaderRec.fhXSDirOffset-XFHeaderRec.sizeof+1    ; offset to super dir ptr
  159. XOffsetToSInit    Equ            XFHeaderRec.fhXSuperInit-XFHeaderRec.sizeof+1    ; offset to super dir ptr
  160. SEBlock                    RECORD 0
  161. seSlot                     ds.b    1                ; offset: $0 (0)        ; Slot number.
  162. sesRsrcId                 ds.b    1                ; offset: $1 (1)        ; sResource Id.
  163. seStatus                 ds.w    1                ; offset: $2 (2)        ; Status of code executed by sExec.
  164. seFlags                     ds.b    1                ; offset: $4 (4)        ; Flags
  165. seFiller0                 ds.b    1                ; offset: $5 (5)        ; Filler, must be SignedByte to align on odd boundry
  166. seFiller1                 ds.b    1                ; offset: $6 (6)        ; Filler
  167. seFiller2                 ds.b    1                ; offset: $7 (7)        ; Filler
  168. seResult                 ds.l    1                ; offset: $8 (8)        ; Result of sLoad.
  169. seIOFileName             ds.l    1                ; offset: $C (12)        ; Pointer to IOFile name.
  170. seDevice                 ds.b    1                ; offset: $10 (16)        ; Which device to read from.
  171. sePartition                 ds.b    1                ; offset: $11 (17)        ; The partition.
  172. seOSType                 ds.b    1                ; offset: $12 (18)        ; Type of OS.
  173. seReserved                 ds.b    1                ; offset: $13 (19)        ; Reserved field.
  174. seRefNum                 ds.b    1                ; offset: $14 (20)        ; RefNum of the driver.
  175. seNumDevices             ds.b    1                ; offset: $15 (21)        ;  Number of devices to load.
  176. seBootState                 ds.b    1                ; offset: $16 (22)        ; State of StartBoot code.
  177. filler                     ds.b    1                ; offset: $17 (23)
  178. sizeof                     EQU *                    ; size:   $18 (24)
  179.                         ENDR
  180. ;   Principle  
  181. ;
  182. ; pascal OSErr SReadByte(SpBlockPtr spBlkPtr)
  183. ;
  184.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  185.         ; parameters:
  186.         ;    spBlkPtr        => A0
  187.         ; returns:
  188.         ;    OSErr           <= D0
  189.         Macro
  190.         _SReadByte
  191.             moveq               #0,D0
  192.             dc.w                $A06E
  193.         EndM
  194.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  195.         IMPORT_CFM_FUNCTION SReadByte
  196.     ENDIF
  197.  
  198. ;
  199. ; pascal OSErr SReadWord(SpBlockPtr spBlkPtr)
  200. ;
  201.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  202.         ; parameters:
  203.         ;    spBlkPtr        => A0
  204.         ; returns:
  205.         ;    OSErr           <= D0
  206.         Macro
  207.         _SReadWord
  208.             moveq               #1,D0
  209.             dc.w                $A06E
  210.         EndM
  211.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  212.         IMPORT_CFM_FUNCTION SReadWord
  213.     ENDIF
  214.  
  215. ;
  216. ; pascal OSErr SReadLong(SpBlockPtr spBlkPtr)
  217. ;
  218.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  219.         ; parameters:
  220.         ;    spBlkPtr        => A0
  221.         ; returns:
  222.         ;    OSErr           <= D0
  223.         Macro
  224.         _SReadLong
  225.             moveq               #2,D0
  226.             dc.w                $A06E
  227.         EndM
  228.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  229.         IMPORT_CFM_FUNCTION SReadLong
  230.     ENDIF
  231.  
  232. ;
  233. ; pascal OSErr SGetCString(SpBlockPtr spBlkPtr)
  234. ;
  235.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  236.         ; parameters:
  237.         ;    spBlkPtr        => A0
  238.         ; returns:
  239.         ;    OSErr           <= D0
  240.         Macro
  241.         _SGetCString
  242.             moveq               #3,D0
  243.             dc.w                $A06E
  244.         EndM
  245.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  246.         IMPORT_CFM_FUNCTION SGetCString
  247.     ENDIF
  248.  
  249. ;
  250. ; pascal OSErr SGetBlock(SpBlockPtr spBlkPtr)
  251. ;
  252.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  253.         ; parameters:
  254.         ;    spBlkPtr        => A0
  255.         ; returns:
  256.         ;    OSErr           <= D0
  257.         Macro
  258.         _SGetBlock
  259.             moveq               #5,D0
  260.             dc.w                $A06E
  261.         EndM
  262.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  263.         IMPORT_CFM_FUNCTION SGetBlock
  264.     ENDIF
  265.  
  266. ;
  267. ; pascal OSErr SFindStruct(SpBlockPtr spBlkPtr)
  268. ;
  269.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  270.         ; parameters:
  271.         ;    spBlkPtr        => A0
  272.         ; returns:
  273.         ;    OSErr           <= D0
  274.         Macro
  275.         _SFindStruct
  276.             moveq               #6,D0
  277.             dc.w                $A06E
  278.         EndM
  279.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  280.         IMPORT_CFM_FUNCTION SFindStruct
  281.     ENDIF
  282.  
  283. ;
  284. ; pascal OSErr SReadStruct(SpBlockPtr spBlkPtr)
  285. ;
  286.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  287.         ; parameters:
  288.         ;    spBlkPtr        => A0
  289.         ; returns:
  290.         ;    OSErr           <= D0
  291.         Macro
  292.         _SReadStruct
  293.             moveq               #7,D0
  294.             dc.w                $A06E
  295.         EndM
  296.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  297.         IMPORT_CFM_FUNCTION SReadStruct
  298.     ENDIF
  299.  
  300. ;   Special  
  301. ;
  302. ; pascal OSErr SReadInfo(SpBlockPtr spBlkPtr)
  303. ;
  304.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  305.         ; parameters:
  306.         ;    spBlkPtr        => A0
  307.         ; returns:
  308.         ;    OSErr           <= D0
  309.         Macro
  310.         _SReadInfo
  311.             moveq               #16,D0
  312.             dc.w                $A06E
  313.         EndM
  314.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  315.         IMPORT_CFM_FUNCTION SReadInfo
  316.     ENDIF
  317.  
  318. ;
  319. ; pascal OSErr SReadPRAMRec(SpBlockPtr spBlkPtr)
  320. ;
  321.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  322.         ; parameters:
  323.         ;    spBlkPtr        => A0
  324.         ; returns:
  325.         ;    OSErr           <= D0
  326.         Macro
  327.         _SReadPRAMRec
  328.             moveq               #17,D0
  329.             dc.w                $A06E
  330.         EndM
  331.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  332.         IMPORT_CFM_FUNCTION SReadPRAMRec
  333.     ENDIF
  334.  
  335. ;
  336. ; pascal OSErr SPutPRAMRec(SpBlockPtr spBlkPtr)
  337. ;
  338.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  339.         ; parameters:
  340.         ;    spBlkPtr        => A0
  341.         ; returns:
  342.         ;    OSErr           <= D0
  343.         Macro
  344.         _SPutPRAMRec
  345.             moveq               #18,D0
  346.             dc.w                $A06E
  347.         EndM
  348.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  349.         IMPORT_CFM_FUNCTION SPutPRAMRec
  350.     ENDIF
  351.  
  352. ;
  353. ; pascal OSErr SReadFHeader(SpBlockPtr spBlkPtr)
  354. ;
  355.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  356.         ; parameters:
  357.         ;    spBlkPtr        => A0
  358.         ; returns:
  359.         ;    OSErr           <= D0
  360.         Macro
  361.         _SReadFHeader
  362.             moveq               #19,D0
  363.             dc.w                $A06E
  364.         EndM
  365.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  366.         IMPORT_CFM_FUNCTION SReadFHeader
  367.     ENDIF
  368.  
  369. ;
  370. ; pascal OSErr SNextSRsrc(SpBlockPtr spBlkPtr)
  371. ;
  372.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  373.         ; parameters:
  374.         ;    spBlkPtr        => A0
  375.         ; returns:
  376.         ;    OSErr           <= D0
  377.         Macro
  378.         _SNextSRsrc
  379.             moveq               #20,D0
  380.             dc.w                $A06E
  381.         EndM
  382.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  383.         IMPORT_CFM_FUNCTION SNextSRsrc
  384.     ENDIF
  385.  
  386. ;
  387. ; pascal OSErr SNextTypeSRsrc(SpBlockPtr spBlkPtr)
  388. ;
  389.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  390.         ; parameters:
  391.         ;    spBlkPtr        => A0
  392.         ; returns:
  393.         ;    OSErr           <= D0
  394.         Macro
  395.         _SNextTypeSRsrc
  396.             moveq               #21,D0
  397.             dc.w                $A06E
  398.         EndM
  399.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  400.         IMPORT_CFM_FUNCTION SNextTypeSRsrc
  401.     ENDIF
  402.  
  403. ;
  404. ; pascal OSErr SRsrcInfo(SpBlockPtr spBlkPtr)
  405. ;
  406.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  407.         ; parameters:
  408.         ;    spBlkPtr        => A0
  409.         ; returns:
  410.         ;    OSErr           <= D0
  411.         Macro
  412.         _SRsrcInfo
  413.             moveq               #22,D0
  414.             dc.w                $A06E
  415.         EndM
  416.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  417.         IMPORT_CFM_FUNCTION SRsrcInfo
  418.     ENDIF
  419.  
  420. ;
  421. ; pascal OSErr SDisposePtr(SpBlockPtr spBlkPtr)
  422. ;
  423.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  424.         ; parameters:
  425.         ;    spBlkPtr        => A0
  426.         ; returns:
  427.         ;    OSErr           <= D0
  428.         Macro
  429.         _SDisposePtr
  430.             moveq               #23,D0
  431.             dc.w                $A06E
  432.         EndM
  433.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  434.         IMPORT_CFM_FUNCTION SDisposePtr
  435.     ENDIF
  436.  
  437. ;
  438. ; pascal OSErr SCkCardStat(SpBlockPtr spBlkPtr)
  439. ;
  440.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  441.         ; parameters:
  442.         ;    spBlkPtr        => A0
  443.         ; returns:
  444.         ;    OSErr           <= D0
  445.         Macro
  446.         _SCkCardStat
  447.             moveq               #24,D0
  448.             dc.w                $A06E
  449.         EndM
  450.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  451.         IMPORT_CFM_FUNCTION SCkCardStat
  452.     ENDIF
  453.  
  454. ;
  455. ; pascal OSErr SReadDrvrName(SpBlockPtr spBlkPtr)
  456. ;
  457.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  458.         ; parameters:
  459.         ;    spBlkPtr        => A0
  460.         ; returns:
  461.         ;    OSErr           <= D0
  462.         Macro
  463.         _SReadDrvrName
  464.             moveq               #25,D0
  465.             dc.w                $A06E
  466.         EndM
  467.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  468.         IMPORT_CFM_FUNCTION SReadDrvrName
  469.     ENDIF
  470.  
  471. ;
  472. ; pascal OSErr SFindSRTRec(SpBlockPtr spBlkPtr)
  473. ;
  474.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  475.         ; parameters:
  476.         ;    spBlkPtr        => A0
  477.         ; returns:
  478.         ;    OSErr           <= D0
  479.         Macro
  480.         _SFindSRTRec
  481.             moveq               #26,D0
  482.             dc.w                $A06E
  483.         EndM
  484.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  485.         IMPORT_CFM_FUNCTION SFindSRTRec
  486.     ENDIF
  487.  
  488. ;
  489. ; pascal OSErr SFindDevBase(SpBlockPtr spBlkPtr)
  490. ;
  491.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  492.         ; parameters:
  493.         ;    spBlkPtr        => A0
  494.         ; returns:
  495.         ;    OSErr           <= D0
  496.         Macro
  497.         _SFindDevBase
  498.             moveq               #27,D0
  499.             dc.w                $A06E
  500.         EndM
  501.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  502.         IMPORT_CFM_FUNCTION SFindDevBase
  503.     ENDIF
  504.  
  505. ;
  506. ; pascal OSErr SFindBigDevBase(SpBlockPtr spBlkPtr)
  507. ;
  508.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  509.         ; parameters:
  510.         ;    spBlkPtr        => A0
  511.         ; returns:
  512.         ;    OSErr           <= D0
  513.         Macro
  514.         _SFindBigDevBase
  515.             moveq               #28,D0
  516.             dc.w                $A06E
  517.         EndM
  518.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  519.         IMPORT_CFM_FUNCTION SFindBigDevBase
  520.     ENDIF
  521.  
  522. ;   Advanced  
  523. ;
  524. ; pascal OSErr InitSDeclMgr(SpBlockPtr spBlkPtr)
  525. ;
  526.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  527.         ; parameters:
  528.         ;    spBlkPtr        => A0
  529.         ; returns:
  530.         ;    OSErr           <= D0
  531.         Macro
  532.         _InitSDeclMgr
  533.             moveq               #32,D0
  534.             dc.w                $A06E
  535.         EndM
  536.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  537.         IMPORT_CFM_FUNCTION InitSDeclMgr
  538.     ENDIF
  539.  
  540. ;
  541. ; pascal OSErr SPrimaryInit(SpBlockPtr spBlkPtr)
  542. ;
  543.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  544.         ; parameters:
  545.         ;    spBlkPtr        => A0
  546.         ; returns:
  547.         ;    OSErr           <= D0
  548.         Macro
  549.         _SPrimaryInit
  550.             moveq               #33,D0
  551.             dc.w                $A06E
  552.         EndM
  553.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  554.         IMPORT_CFM_FUNCTION SPrimaryInit
  555.     ENDIF
  556.  
  557. ;
  558. ; pascal OSErr SCardChanged(SpBlockPtr spBlkPtr)
  559. ;
  560.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  561.         ; parameters:
  562.         ;    spBlkPtr        => A0
  563.         ; returns:
  564.         ;    OSErr           <= D0
  565.         Macro
  566.         _SCardChanged
  567.             moveq               #34,D0
  568.             dc.w                $A06E
  569.         EndM
  570.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  571.         IMPORT_CFM_FUNCTION SCardChanged
  572.     ENDIF
  573.  
  574. ;
  575. ; pascal OSErr SExec(SpBlockPtr spBlkPtr)
  576. ;
  577.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  578.         ; parameters:
  579.         ;    spBlkPtr        => A0
  580.         ; returns:
  581.         ;    OSErr           <= D0
  582.         Macro
  583.         _SExec
  584.             moveq               #35,D0
  585.             dc.w                $A06E
  586.         EndM
  587.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  588.         IMPORT_CFM_FUNCTION SExec
  589.     ENDIF
  590.  
  591. ;
  592. ; pascal OSErr SOffsetData(SpBlockPtr spBlkPtr)
  593. ;
  594.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  595.         ; parameters:
  596.         ;    spBlkPtr        => A0
  597.         ; returns:
  598.         ;    OSErr           <= D0
  599.         Macro
  600.         _SOffsetData
  601.             moveq               #36,D0
  602.             dc.w                $A06E
  603.         EndM
  604.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  605.         IMPORT_CFM_FUNCTION SOffsetData
  606.     ENDIF
  607.  
  608. ;
  609. ; pascal OSErr SInitPRAMRecs(SpBlockPtr spBlkPtr)
  610. ;
  611.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  612.         ; parameters:
  613.         ;    spBlkPtr        => A0
  614.         ; returns:
  615.         ;    OSErr           <= D0
  616.         Macro
  617.         _SInitPRAMRecs
  618.             moveq               #37,D0
  619.             dc.w                $A06E
  620.         EndM
  621.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  622.         IMPORT_CFM_FUNCTION SInitPRAMRecs
  623.     ENDIF
  624.  
  625. ;
  626. ; pascal OSErr SReadPBSize(SpBlockPtr spBlkPtr)
  627. ;
  628.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  629.         ; parameters:
  630.         ;    spBlkPtr        => A0
  631.         ; returns:
  632.         ;    OSErr           <= D0
  633.         Macro
  634.         _SReadPBSize
  635.             moveq               #38,D0
  636.             dc.w                $A06E
  637.         EndM
  638.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  639.         IMPORT_CFM_FUNCTION SReadPBSize
  640.     ENDIF
  641.  
  642. ;
  643. ; pascal OSErr SCalcStep(SpBlockPtr spBlkPtr)
  644. ;
  645.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  646.         ; parameters:
  647.         ;    spBlkPtr        => A0
  648.         ; returns:
  649.         ;    OSErr           <= D0
  650.         Macro
  651.         _SCalcStep
  652.             moveq               #40,D0
  653.             dc.w                $A06E
  654.         EndM
  655.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  656.         IMPORT_CFM_FUNCTION SCalcStep
  657.     ENDIF
  658.  
  659. ;
  660. ; pascal OSErr SInitSRsrcTable(SpBlockPtr spBlkPtr)
  661. ;
  662.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  663.         ; parameters:
  664.         ;    spBlkPtr        => A0
  665.         ; returns:
  666.         ;    OSErr           <= D0
  667.         Macro
  668.         _SInitSRsrcTable
  669.             moveq               #41,D0
  670.             dc.w                $A06E
  671.         EndM
  672.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  673.         IMPORT_CFM_FUNCTION SInitSRsrcTable
  674.     ENDIF
  675.  
  676. ;
  677. ; pascal OSErr SSearchSRT(SpBlockPtr spBlkPtr)
  678. ;
  679.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  680.         ; parameters:
  681.         ;    spBlkPtr        => A0
  682.         ; returns:
  683.         ;    OSErr           <= D0
  684.         Macro
  685.         _SSearchSRT
  686.             moveq               #42,D0
  687.             dc.w                $A06E
  688.         EndM
  689.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  690.         IMPORT_CFM_FUNCTION SSearchSRT
  691.     ENDIF
  692.  
  693. ;
  694. ; pascal OSErr SUpdateSRT(SpBlockPtr spBlkPtr)
  695. ;
  696.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  697.         ; parameters:
  698.         ;    spBlkPtr        => A0
  699.         ; returns:
  700.         ;    OSErr           <= D0
  701.         Macro
  702.         _SUpdateSRT
  703.             moveq               #43,D0
  704.             dc.w                $A06E
  705.         EndM
  706.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  707.         IMPORT_CFM_FUNCTION SUpdateSRT
  708.     ENDIF
  709.  
  710. ;
  711. ; pascal OSErr SCalcSPointer(SpBlockPtr spBlkPtr)
  712. ;
  713.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  714.         ; parameters:
  715.         ;    spBlkPtr        => A0
  716.         ; returns:
  717.         ;    OSErr           <= D0
  718.         Macro
  719.         _SCalcSPointer
  720.             moveq               #44,D0
  721.             dc.w                $A06E
  722.         EndM
  723.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  724.         IMPORT_CFM_FUNCTION SCalcSPointer
  725.     ENDIF
  726.  
  727. ;
  728. ; pascal OSErr SGetDriver(SpBlockPtr spBlkPtr)
  729. ;
  730.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  731.         ; parameters:
  732.         ;    spBlkPtr        => A0
  733.         ; returns:
  734.         ;    OSErr           <= D0
  735.         Macro
  736.         _SGetDriver
  737.             moveq               #45,D0
  738.             dc.w                $A06E
  739.         EndM
  740.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  741.         IMPORT_CFM_FUNCTION SGetDriver
  742.     ENDIF
  743.  
  744. ;
  745. ; pascal OSErr SPtrToSlot(SpBlockPtr spBlkPtr)
  746. ;
  747.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  748.         ; parameters:
  749.         ;    spBlkPtr        => A0
  750.         ; returns:
  751.         ;    OSErr           <= D0
  752.         Macro
  753.         _SPtrToSlot
  754.             moveq               #46,D0
  755.             dc.w                $A06E
  756.         EndM
  757.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  758.         IMPORT_CFM_FUNCTION SPtrToSlot
  759.     ENDIF
  760.  
  761. ;
  762. ; pascal OSErr SFindSInfoRecPtr(SpBlockPtr spBlkPtr)
  763. ;
  764.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  765.         ; parameters:
  766.         ;    spBlkPtr        => A0
  767.         ; returns:
  768.         ;    OSErr           <= D0
  769.         Macro
  770.         _SFindSInfoRecPtr
  771.             moveq               #47,D0
  772.             dc.w                $A06E
  773.         EndM
  774.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  775.         IMPORT_CFM_FUNCTION SFindSInfoRecPtr
  776.     ENDIF
  777.  
  778. ;
  779. ; pascal OSErr SFindSRsrcPtr(SpBlockPtr spBlkPtr)
  780. ;
  781.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  782.         ; parameters:
  783.         ;    spBlkPtr        => A0
  784.         ; returns:
  785.         ;    OSErr           <= D0
  786.         Macro
  787.         _SFindSRsrcPtr
  788.             moveq               #48,D0
  789.             dc.w                $A06E
  790.         EndM
  791.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  792.         IMPORT_CFM_FUNCTION SFindSRsrcPtr
  793.     ENDIF
  794.  
  795. ;
  796. ; pascal OSErr SDeleteSRTRec(SpBlockPtr spBlkPtr)
  797. ;
  798.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  799.         ; parameters:
  800.         ;    spBlkPtr        => A0
  801.         ; returns:
  802.         ;    OSErr           <= D0
  803.         Macro
  804.         _SDeleteSRTRec
  805.             moveq               #49,D0
  806.             dc.w                $A06E
  807.         EndM
  808.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  809.         IMPORT_CFM_FUNCTION SDeleteSRTRec
  810.     ENDIF
  811.  
  812. ;
  813. ; pascal OSErr SSecondaryInit(SpBlockPtr spBlkPtr)
  814. ;
  815.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  816.         ; parameters:
  817.         ;    spBlkPtr        => A0
  818.         ; returns:
  819.         ;    OSErr           <= D0
  820.         Macro
  821.         _SSecondaryInit
  822.             moveq               #50,D0
  823.             dc.w                $A06E
  824.         EndM
  825.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  826.         IMPORT_CFM_FUNCTION SSecondaryInit
  827.     ENDIF
  828.  
  829. ;
  830. ; pascal OSErr SInitSlotPRAM(SpBlockPtr spBlkPtr)
  831. ;
  832.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  833.         ; parameters:
  834.         ;    spBlkPtr        => A0
  835.         ; returns:
  836.         ;    OSErr           <= D0
  837.         Macro
  838.         _SInitSlotPRAM
  839.             moveq               #51,D0
  840.             dc.w                $A06E
  841.         EndM
  842.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  843.         IMPORT_CFM_FUNCTION SInitSlotPRAM
  844.     ENDIF
  845.  
  846. ;
  847. ; pascal OSErr OpenSlot(ParmBlkPtr paramBlock, Boolean async)
  848. ;
  849.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  850.         IMPORT_CFM_FUNCTION OpenSlot
  851.     ENDIF
  852.  
  853. ;
  854. ; pascal OSErr OpenSlotSync(ParmBlkPtr paramBlock)
  855. ;
  856.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  857.         ; parameters:
  858.         ;    paramBlock      => A0
  859.         ; returns:
  860.         ;    OSErr           <= D0
  861.         _OpenSlotSync:    OPWORD    $A200
  862.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  863.         IMPORT_CFM_FUNCTION OpenSlotSync
  864.     ENDIF
  865.  
  866. ;
  867. ; pascal OSErr OpenSlotAsync(ParmBlkPtr paramBlock)
  868. ;
  869.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  870.         ; parameters:
  871.         ;    paramBlock      => A0
  872.         ; returns:
  873.         ;    OSErr           <= D0
  874.         _OpenSlotAsync:    OPWORD    $A600
  875.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  876.         IMPORT_CFM_FUNCTION OpenSlotAsync
  877.     ENDIF
  878.  
  879. ;   Device Manager Slot Support  
  880. ;
  881. ; pascal OSErr SIntInstall(SQElemPtr sIntQElemPtr, short theSlot)
  882. ;
  883.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  884.         ; parameters:
  885.         ;    sIntQElemPtrtheSlot=> A0
  886.         ;    theSlot         => D0
  887.         ; returns:
  888.         ;    OSErr           <= D0
  889.         _SIntInstall:    OPWORD    $A075
  890.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  891.         IMPORT_CFM_FUNCTION SIntInstall
  892.     ENDIF
  893.  
  894. ;
  895. ; pascal OSErr SIntRemove(SQElemPtr sIntQElemPtr, short theSlot)
  896. ;
  897.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  898.         ; parameters:
  899.         ;    sIntQElemPtrtheSlot=> A0
  900.         ;    theSlot         => D0
  901.         ; returns:
  902.         ;    OSErr           <= D0
  903.         _SIntRemove:    OPWORD    $A076
  904.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  905.         IMPORT_CFM_FUNCTION SIntRemove
  906.     ENDIF
  907.  
  908. ;
  909. ; pascal OSErr SVersion(SpBlockPtr spBlkPtr)
  910. ;
  911.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  912.         ; parameters:
  913.         ;    spBlkPtr        => A0
  914.         ; returns:
  915.         ;    OSErr           <= D0
  916.         Macro
  917.         _SVersion
  918.             moveq               #8,D0
  919.             dc.w                $A06E
  920.         EndM
  921.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  922.         IMPORT_CFM_FUNCTION SVersion
  923.     ENDIF
  924.  
  925. ;
  926. ; pascal OSErr SetSRsrcState(SpBlockPtr spBlkPtr)
  927. ;
  928.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  929.         ; parameters:
  930.         ;    spBlkPtr        => A0
  931.         ; returns:
  932.         ;    OSErr           <= D0
  933.         Macro
  934.         _SetSRsrcState
  935.             moveq               #9,D0
  936.             dc.w                $A06E
  937.         EndM
  938.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  939.         IMPORT_CFM_FUNCTION SetSRsrcState
  940.     ENDIF
  941.  
  942. ;
  943. ; pascal OSErr InsertSRTRec(SpBlockPtr spBlkPtr)
  944. ;
  945.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  946.         ; parameters:
  947.         ;    spBlkPtr        => A0
  948.         ; returns:
  949.         ;    OSErr           <= D0
  950.         Macro
  951.         _InsertSRTRec
  952.             moveq               #10,D0
  953.             dc.w                $A06E
  954.         EndM
  955.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  956.         IMPORT_CFM_FUNCTION InsertSRTRec
  957.     ENDIF
  958.  
  959. ;
  960. ; pascal OSErr SGetSRsrc(SpBlockPtr spBlkPtr)
  961. ;
  962.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  963.         ; parameters:
  964.         ;    spBlkPtr        => A0
  965.         ; returns:
  966.         ;    OSErr           <= D0
  967.         Macro
  968.         _SGetSRsrc
  969.             moveq               #11,D0
  970.             dc.w                $A06E
  971.         EndM
  972.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  973.         IMPORT_CFM_FUNCTION SGetSRsrc
  974.     ENDIF
  975.  
  976. ;
  977. ; pascal OSErr SGetTypeSRsrc(SpBlockPtr spBlkPtr)
  978. ;
  979.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  980.         ; parameters:
  981.         ;    spBlkPtr        => A0
  982.         ; returns:
  983.         ;    OSErr           <= D0
  984.         Macro
  985.         _SGetTypeSRsrc
  986.             moveq               #12,D0
  987.             dc.w                $A06E
  988.         EndM
  989.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  990.         IMPORT_CFM_FUNCTION SGetTypeSRsrc
  991.     ENDIF
  992.  
  993. ;
  994. ; pascal OSErr SGetSRsrcPtr(SpBlockPtr spBlkPtr)
  995. ;
  996.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  997.         ; parameters:
  998.         ;    spBlkPtr        => A0
  999.         ; returns:
  1000.         ;    OSErr           <= D0
  1001.         Macro
  1002.         _SGetSRsrcPtr
  1003.             moveq               #29,D0
  1004.             dc.w                $A06E
  1005.         EndM
  1006.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1007.         IMPORT_CFM_FUNCTION SGetSRsrcPtr
  1008.     ENDIF
  1009.  
  1010.  
  1011.  
  1012.     ENDIF ; __SLOTS__ 
  1013.  
  1014.